/**
 * 交易市场
 * 1. 买卖交易
 * 2. 成交价格统计
 */

import bag_component from "../../component/bag_component";
import gameCfg from "../../gameCfg";
import player from "../rpg/entity/player";
import { marketListItem } from "../../shared/api_client/market/PtlList";
import { Item } from "../../shared/face/index";
import { ComType } from "../tool/component";
import sdk from '../index';
import Counter from "./Counter";
import UserManager from "./UserManager";
import MailManage from "./MailManage";
import { 资源枚举, ItemType } from "../../shared/face/enums";
import common from "../tool/common";

// 市场商品接口
interface MarketItem {
    _id: string;
    item: Item;
    put_id: string; // 上架者ID
    put_time: number; // 上架时间
    sell_price: number; // 售价
    status: 'on_sale' | 'sold' | 'expired';
}

// 市场日志接口
interface MarketLog {
    _id: string;
    item_id: string;
    buyer_id: string;
    seller_id: string;
    price: number;
    trade_time: number;
    item_name: string;
}

class MarketManage {
    // 内存存储
    private marketItems = new Map<string, MarketItem>();
    private marketLogs = new Map<string, MarketLog>();
    private pendingItems = new Map<string, MarketItem>(); // 待存储的商品
    private pendingLogs = new Map<string, MarketLog>(); // 待存储的日志
    private pendingUpdates = new Map<string, Partial<MarketItem>>(); // 待更新的商品

    async init() {
        try {
            // 加载市场数据到内存
            await this.loadMarketData();

            // 加载交易日志到内存
            await this.loadMarketLogs();

            console.log(`市场管理器初始化完成，加载了 ${this.marketItems.size} 个商品，${this.marketLogs.size} 条交易记录`);
        } catch (error) {
            console.error('市场管理器初始化失败:', error);
        }
    }

    /**
     * 加载市场数据到内存
     */
    private async loadMarketData() {
        try {
            const data = await sdk.db.find('market_items');
            this.marketItems.clear();
            data.forEach((item: any) => {
                if (item.status === 'on_sale') {
                    this.marketItems.set(item._id, item);
                }
            });
            console.log(`加载了 ${this.marketItems.size} 个在售商品到内存`);
        } catch (error) {
            console.error('加载市场数据失败:', error);
        }
    }

    /**
     * 加载市场日志到内存
     */
    private async loadMarketLogs() {
        try {
            const data = await sdk.db.find('market_logs');
            this.marketLogs.clear();
            data.forEach((log: any) => {
                this.marketLogs.set(log._id, log);
            });
            console.log(`加载了 ${this.marketLogs.size} 条交易记录到内存`);
        } catch (error) {
            console.error('加载市场日志失败:', error);
        }
    }

    /**
     * 保存市场数据到数据库
     */
    async save() {
        try {
            // 批量存储待存储的商品
            if (this.pendingItems.size > 0) {
                const itemsToInsert: MarketItem[] = Array.from(this.pendingItems.values());
                if (itemsToInsert.length > 0) {
                    await sdk.db.getCollection('market_items').insertMany(itemsToInsert as any);
                    console.log(`批量存储了 ${itemsToInsert.length} 个商品到数据库`);
                }
                this.pendingItems.clear();
            }

            // 批量存储待存储的日志
            if (this.pendingLogs.size > 0) {
                const logsToInsert: MarketLog[] = Array.from(this.pendingLogs.values());
                if (logsToInsert.length > 0) {
                    await sdk.db.getCollection('market_logs').insertMany(logsToInsert as any);
                    console.log(`批量存储了 ${logsToInsert.length} 条交易记录到数据库`);
                }
                this.pendingLogs.clear();
            }

            // 批量更新商品状态
            if (this.pendingUpdates.size > 0) {
                for (const [itemId, updateData] of this.pendingUpdates.entries()) {
                    await sdk.db.update('market_items', { _id: itemId }, updateData);
                }
                console.log(`批量更新了 ${this.pendingUpdates.size} 个商品状态`);
                this.pendingUpdates.clear();
            }

            console.log('市场数据保存完成');
        } catch (error) {
            console.error('保存市场数据失败:', error);
        }
    }

    /**
     * 上架商品 - 存储到内存
     * @param item 道具
     * @param price 价格
     * @param sellerId 卖家ID
     */
    async putOnSale(item: Item, price: number, sellerId: string): Promise<string> {
        try {
            const marketItem: MarketItem = {
                _id: sdk.tool.common.uuid,
                item: item,
                put_id: sellerId,
                put_time: Date.now(),
                sell_price: price,
                status: 'on_sale'
            };

            // 存储到内存
            this.marketItems.set(marketItem._id, marketItem);

            // 添加到待存储队列
            this.pendingItems.set(marketItem._id, marketItem);

            console.log(`物品上架--${item.name}价格${price}`);
            return marketItem._id;
        } catch (error) {
            console.error('上架商品失败:', error);
            throw error;
        }
    }

    /**
     * 购买商品 - 在内存中处理
     * @param itemId 商品ID
     * @param buyer 买家
     */
    buy(itemId: string, buyer: any,count:number): string | null {
        try {
            const item = this.marketItems.get(itemId);
            if (!item) {
                console.log('商品不存在');
                return '商品不存在';
            }
            if(item.item.count<count){
                count = item.item.count;
            }
            // 检查买家金币是否足够
            const bagCom = buyer.getComponent(ComType.背包) as bag_component;
            const buyerGold = bagCom.goldBuy(item.sell_price*count);
            if (!buyerGold) {
                return '金币不足';
            }
     
            // 给买家添加商品
            let buyItem = JSON.parse(JSON.stringify(item.item));
            buyItem.count = count;
            MailManage.send('admin', buyer.id, 30, '交易所·购买完成', `您已购买 ${buyItem.name}x${buyItem.count}`, [buyItem]);

            // 给卖家添加金币
            let sellItem = sdk.prop.createProp({ type: ItemType.资源, id: 资源枚举.金币, count: item.sell_price * buyItem.count });
            MailManage.send('admin', item.put_id, 30, '交易所·出售完成', `您的商品 ${item.item.name}x${buyItem.count} 已售出，获得 ${item.sell_price * buyItem.count} 金币`, [sellItem]);

            // 记录交易日志到内存
            this.recordTrade(item, buyer.id, item.put_id, item.sell_price);

            // 从市场移除商品（更新状态）
            this.removeFromMarket(itemId,count);

            console.log('商品成交', item.item.name);
            return null; // 成功
        } catch (error) {
            console.error('购买商品失败:', error);
            return '购买失败';
        }
    }

    /**
     * 记录交易日志 - 存储到内存
     */
    private recordTrade(item: MarketItem, buyerId: string, sellerId: string, price: number) {
        try {
            const logId = `${item._id}_${Date.now()}`;
            const log: MarketLog = {
                _id: logId,
                item_id: item._id,
                buyer_id: buyerId,
                seller_id: sellerId,
                price: price,
                trade_time: Date.now(),
                item_name: item.item.name
            };

            // 存储到内存
            this.marketLogs.set(logId, log);

            // 添加到待存储队列
            this.pendingLogs.set(logId, log);
        } catch (error) {
            console.error('记录交易日志失败:', error);
        }
    }

    /**
     * 从市场移除商品 - 在内存中处理
     */
    private removeFromMarket(itemId: string, count: number) {
        try {
            const item = this.marketItems.get(itemId);
            if (item) {
                // 减少商品数量
                item.item.count -= count;
                
                // 如果商品数量为0或负数，则从市场移除
                if (item.item.count <= 0) {
                    // 更新状态为已售出
                    item.status = 'sold';
                    
                    // 添加到待更新队列
                    this.pendingUpdates.set(itemId, { status: 'sold' });
                    
                    // 从内存中移除
                    this.marketItems.delete(itemId);
                    
                    console.log(`商品 ${item.item.name} 已售罄，从市场移除`);
                } else {
                    // 商品还有剩余，更新数量
                    this.pendingUpdates.set(itemId, { 
                        item: item.item 
                    });
                    
                    console.log(`商品 ${item.item.name} 剩余数量: ${item.item.count}`);
                }
            }
        } catch (error) {
            console.error('从市场移除商品失败:', error);
        }
    }

    /**
     * 获取市场商品列表 - 从内存中获取
     */
    getMarketItems(): MarketItem[] {
        return Array.from(this.marketItems.values());
    }

    /**
     * 获取市场日志 - 从内存中获取
     */
    getMarketLogs(): MarketLog[] {
        return Array.from(this.marketLogs.values());
    }

    /**
     * 获取商品信息 - 从内存中获取
     * @param itemId 商品ID
     */
    getItemInfo(itemId: string): MarketItem | undefined {
        return this.marketItems.get(itemId);
    }

    /**
     * 下架商品 - 在内存中处理
     * @param itemId 商品ID
     * @param sellerId 卖家ID
     */
    async takeOffSale(itemId: string, sellerId: string): Promise<boolean> {
        try {
            const item = this.marketItems.get(itemId);
            if (!item) {
                console.error(`商品不存在: ${itemId}`);
                return false;
            }

            if (item.put_id !== sellerId) {
                console.error(`商品不属于卖家: ${itemId}`);
                return false;
            }

            // 更新状态为已过期
            item.status = 'expired';

            // 添加到待更新队列
            this.pendingUpdates.set(itemId, { status: 'expired' });

            // 从内存中移除
            this.marketItems.delete(itemId);

            console.log(`商品下架成功: ${itemId}`);
            return true;
        } catch (error) {
            console.error('下架商品失败:', error);
            return false;
        }
    }

    /**
     * 上架商品（简化接口）
     * @param item 道具
     * @param user 用户
     * @param price 价格
     */
    put(item: Item, user_id: any, price: number) {
        return this.putOnSale(item, price, user_id);
    }

    /**
     * 获取市场商品列表（简化接口）
     */
    get list() {
        return this.getMarketItems();
    }

    /**
     * 获取商品类型列表
     */
    itemListType(): any[] {
        return this.getMarketItems().map(item => ({
            id: item._id,
            name: item.item.name,
            price: item.sell_price,
            seller: item.put_id,
            putTime: item.put_time
        }));
    }
}

export default new MarketManage();